/*
 *    This program is free software; you can redistribute it and/or modify
 *    it under the terms of the GNU General Public License as published by
 *    the Free Software Foundation; either version 2 of the License, or
 *    (at your option) any later version.
 *
 *    This program is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *    GNU General Public License for more details.
 *
 *    You should have received a copy of the GNU General Public License
 *    along with this program; if not, write to the Free Software
 *    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

/*
 *    AdaBoostM1.java
 *    Copyright (C) 1999 University of Waikato, Hamilton, New Zealand
 *
 */

package weka.classifiers.meta;

import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;
import java.util.Random;
import java.util.Vector;

import weka.classifiers.Classifier;
import weka.classifiers.Evaluation;
import weka.classifiers.RandomizableIteratedSingleClassifierEnhancer;
import weka.classifiers.Sourcable;
import weka.core.Capabilities;
import weka.core.Instance;
import weka.core.Instances;
import weka.core.Option;
import weka.core.Randomizable;
import weka.core.RevisionUtils;
import weka.core.TechnicalInformation;
import weka.core.TechnicalInformationHandler;
import weka.core.Utils;
import weka.core.WeightedInstancesHandler;
import weka.core.Capabilities.Capability;
import weka.core.TechnicalInformation.Field;
import weka.core.TechnicalInformation.Type;

/**
 <!-- globalinfo-start -->
 * Class for boosting a nominal class classifier using the Adaboost M1 method. Only nominal class problems can be tackled. Often dramatically improves performance, but sometimes overfits.<br/>
 * <br/>
 * For more information, see<br/>
 * <br/>
 * Yoav Freund, Robert E. Schapire: Experiments with a new boosting algorithm. In: Thirteenth International Conference on Machine Learning, San Francisco, 148-156, 1996.
 * <p/>
 <!-- globalinfo-end -->
 *
 <!-- technical-bibtex-start -->
 * BibTeX:
 * <pre>
 * &#64;inproceedings{Freund1996,
 *    address = {San Francisco},
 *    author = {Yoav Freund and Robert E. Schapire},
 *    booktitle = {Thirteenth International Conference on Machine Learning},
 *    pages = {148-156},
 *    publisher = {Morgan Kaufmann},
 *    title = {Experiments with a new boosting algorithm},
 *    year = {1996}
 * }
 * </pre>
 * <p/>
 <!-- technical-bibtex-end -->
 *
 <!-- options-start -->
 * Valid options are: <p/>
 * 
 * <pre> -P &lt;num&gt;
 *  Percentage of weight mass to base training on.
 *  (default 100, reduce to around 90 speed up)</pre>
 * 
 * <pre> -Q
 *  Use resampling for boosting.</pre>
 * 
 * <pre> -S &lt;num&gt;
 *  Random number seed.
 *  (default 1)</pre>
 * 
 * <pre> -I &lt;num&gt;
 *  Number of iterations.
 *  (default 10)</pre>
 * 
 * <pre> -D
 *  If set, classifier is run in debug mode and
 *  may output additional info to the console</pre>
 * 
 * <pre> -W
 *  Full name of base classifier.
 *  (default: weka.classifiers.trees.DecisionStump)</pre>
 * 
 * <pre> 
 * Options specific to classifier weka.classifiers.trees.DecisionStump:
 * </pre>
 * 
 * <pre> -D
 *  If set, classifier is run in debug mode and
 *  may output additional info to the console</pre>
 * 
 <!-- options-end -->
 *
 * Options after -- are passed to the designated classifier.<p>
 *
 * @author Eibe Frank (eibe@cs.waikato.ac.nz)
 * @author Len Trigg (trigg@cs.waikato.ac.nz)
 * @version $Revision: 5928 $ 
 */
public class AdaBoostM1 
extends RandomizableIteratedSingleClassifierEnhancer 
implements WeightedInstancesHandler, Sourcable, TechnicalInformationHandler {

	/** for serialization */
	static final long serialVersionUID = -7378107808933117974L;

	/** Max num iterations tried to find classifier with non-zero error. */ 
	private static int MAX_NUM_RESAMPLING_ITERATIONS = 10;

	/** Array for storing the weights for the votes. */
	protected double [] m_Betas;

	/** The number of successfully generated base classifiers. */
	protected int m_NumIterationsPerformed;

	/** Weight Threshold. The percentage of weight mass used in training */
	protected int m_WeightThreshold = 100;

	/** Use boosting with reweighting? */
	protected boolean m_UseResampling;

	/** The number of classes */
	protected int m_NumClasses;

	/** a ZeroR model in case no model can be built from the data */
	protected Classifier m_ZeroR;

	/**
	 * Constructor.
	 */
	public AdaBoostM1() {

		m_Classifier = new weka.classifiers.trees.DecisionStump();
	}

	/**
	 * Returns a string describing classifier
	 * @return a description suitable for
	 * displaying in the explorer/experimenter gui
	 */
	public String globalInfo() {

		return "Class for boosting a nominal class classifier using the Adaboost "
		+ "M1 method. Only nominal class problems can be tackled. Often "
		+ "dramatically improves performance, but sometimes overfits.\n\n"
		+ "For more information, see\n\n"
		+ getTechnicalInformation().toString();
	}

	/**
	 * Returns an instance of a TechnicalInformation object, containing 
	 * detailed information about the technical background of this class,
	 * e.g., paper reference or book this class is based on.
	 * 
	 * @return the technical information about this class
	 */
	public TechnicalInformation getTechnicalInformation() {
		TechnicalInformation 	result;

		result = new TechnicalInformation(Type.INPROCEEDINGS);
		result.setValue(Field.AUTHOR, "Yoav Freund and Robert E. Schapire");
		result.setValue(Field.TITLE, "Experiments with a new boosting algorithm");
		result.setValue(Field.BOOKTITLE, "Thirteenth International Conference on Machine Learning");
		result.setValue(Field.YEAR, "1996");
		result.setValue(Field.PAGES, "148-156");
		result.setValue(Field.PUBLISHER, "Morgan Kaufmann");
		result.setValue(Field.ADDRESS, "San Francisco");

		return result;
	}

	/**
	 * String describing default classifier.
	 * 
	 * @return the default classifier classname
	 */
	protected String defaultClassifierString() {

		return "weka.classifiers.trees.DecisionStump";
	}

	/**
	 * Select only instances with weights that contribute to 
	 * the specified quantile of the weight distribution
	 *
	 * @param data the input instances
	 * @param quantile the specified quantile eg 0.9 to select 
	 * 90% of the weight mass
	 * @return the selected instances
	 */
	protected Instances selectWeightQuantile(Instances data, double quantile) { 

		int numInstances = data.numInstances();
		Instances trainData = new Instances(data, numInstances);
		double [] weights = new double [numInstances];

		double sumOfWeights = 0;
		for(int i = 0; i < numInstances; i++) {
			weights[i] = data.instance(i).weight();
			sumOfWeights += weights[i];
		}
		double weightMassToSelect = sumOfWeights * quantile;
		int [] sortedIndices = Utils.sort(weights);

		// Select the instances
		sumOfWeights = 0;
		for(int i = numInstances - 1; i >= 0; i--) {
			Instance instance = (Instance)data.instance(sortedIndices[i]).copy();
			trainData.add(instance);
			sumOfWeights += weights[sortedIndices[i]];
			if ((sumOfWeights > weightMassToSelect) && 
					(i > 0) && 
					(weights[sortedIndices[i]] != weights[sortedIndices[i - 1]])) {
				break;
			}
		}
		if (m_Debug) {
			System.err.println("Selected " + trainData.numInstances()
					+ " out of " + numInstances);
		}
		return trainData;
	}

	/**
	 * Returns an enumeration describing the available options.
	 *
	 * @return an enumeration of all the available options.
	 */
	public Enumeration listOptions() {

		Vector newVector = new Vector();

		newVector.addElement(new Option(
				"\tPercentage of weight mass to base training on.\n"
				+"\t(default 100, reduce to around 90 speed up)",
				"P", 1, "-P <num>"));

		newVector.addElement(new Option(
				"\tUse resampling for boosting.",
				"Q", 0, "-Q"));

		Enumeration enu = super.listOptions();
		while (enu.hasMoreElements()) {
			newVector.addElement(enu.nextElement());
		}

		return newVector.elements();
	}


	/**
	 * Parses a given list of options. <p/>
	 *
   <!-- options-start -->
	 * Valid options are: <p/>
	 * 
	 * <pre> -P &lt;num&gt;
	 *  Percentage of weight mass to base training on.
	 *  (default 100, reduce to around 90 speed up)</pre>
	 * 
	 * <pre> -Q
	 *  Use resampling for boosting.</pre>
	 * 
	 * <pre> -S &lt;num&gt;
	 *  Random number seed.
	 *  (default 1)</pre>
	 * 
	 * <pre> -I &lt;num&gt;
	 *  Number of iterations.
	 *  (default 10)</pre>
	 * 
	 * <pre> -D
	 *  If set, classifier is run in debug mode and
	 *  may output additional info to the console</pre>
	 * 
	 * <pre> -W
	 *  Full name of base classifier.
	 *  (default: weka.classifiers.trees.DecisionStump)</pre>
	 * 
	 * <pre> 
	 * Options specific to classifier weka.classifiers.trees.DecisionStump:
	 * </pre>
	 * 
	 * <pre> -D
	 *  If set, classifier is run in debug mode and
	 *  may output additional info to the console</pre>
	 * 
   <!-- options-end -->
	 *
	 * Options after -- are passed to the designated classifier.<p>
	 *
	 * @param options the list of options as an array of strings
	 * @throws Exception if an option is not supported
	 */
	public void setOptions(String[] options) throws Exception {

		String thresholdString = Utils.getOption('P', options);
		if (thresholdString.length() != 0) {
			setWeightThreshold(Integer.parseInt(thresholdString));
		} else {
			setWeightThreshold(100);
		}

		setUseResampling(Utils.getFlag('Q', options));

		super.setOptions(options);
	}

	/**
	 * Gets the current settings of the Classifier.
	 *
	 * @return an array of strings suitable for passing to setOptions
	 */
	public String[] getOptions() {
		Vector        result;
		String[]      options;
		int           i;

		result = new Vector();

		if (getUseResampling())
			result.add("-Q");

		result.add("-P");
		result.add("" + getWeightThreshold());

		options = super.getOptions();
		for (i = 0; i < options.length; i++)
			result.add(options[i]);

		return (String[]) result.toArray(new String[result.size()]);
	}

	/**
	 * Returns the tip text for this property
	 * @return tip text for this property suitable for
	 * displaying in the explorer/experimenter gui
	 */
	public String weightThresholdTipText() {
		return "Weight threshold for weight pruning.";
	}

	/**
	 * Set weight threshold
	 *
	 * @param threshold the percentage of weight mass used for training
	 */
	public void setWeightThreshold(int threshold) {

		m_WeightThreshold = threshold;
	}

	/**
	 * Get the degree of weight thresholding
	 *
	 * @return the percentage of weight mass used for training
	 */
	public int getWeightThreshold() {

		return m_WeightThreshold;
	}

	/**
	 * Returns the tip text for this property
	 * @return tip text for this property suitable for
	 * displaying in the explorer/experimenter gui
	 */
	public String useResamplingTipText() {
		return "Whether resampling is used instead of reweighting.";
	}

	/**
	 * Set resampling mode
	 *
	 * @param r true if resampling should be done
	 */
	public void setUseResampling(boolean r) {

		m_UseResampling = r;
	}

	/**
	 * Get whether resampling is turned on
	 *
	 * @return true if resampling output is on
	 */
	public boolean getUseResampling() {

		return m_UseResampling;
	}

	/**
	 * Returns default capabilities of the classifier.
	 *
	 * @return      the capabilities of this classifier
	 */
	public Capabilities getCapabilities() {
		Capabilities result = super.getCapabilities();

		// class
		result.disableAllClasses();
		result.disableAllClassDependencies();
		if (super.getCapabilities().handles(Capability.NOMINAL_CLASS))
			result.enable(Capability.NOMINAL_CLASS);
		if (super.getCapabilities().handles(Capability.BINARY_CLASS))
			result.enable(Capability.BINARY_CLASS);

		return result;
	}

	/**
	 * Boosting method.
	 *
	 * @param data the training data to be used for generating the
	 * boosted classifier.
	 * @throws Exception if the classifier could not be built successfully
	 */

	public void buildClassifier(Instances data) throws Exception {

		super.buildClassifier(data);

		// can classifier handle the data?
		getCapabilities().testWithFail(data);

		// remove instances with missing class
		data = new Instances(data);
		data.deleteWithMissingClass();

		// only class? -> build ZeroR model
		if (data.numAttributes() == 1) {
			System.err.println(
					"Cannot build model (only class attribute present in data!), "
					+ "using ZeroR model instead!");
			m_ZeroR = new weka.classifiers.rules.ZeroR();
			m_ZeroR.buildClassifier(data);
			return;
		}
		else {
			m_ZeroR = null;
		}

		m_NumClasses = data.numClasses();
		if ((!m_UseResampling) && 
				(m_Classifier instanceof WeightedInstancesHandler)) {
			buildClassifierWithWeights(data);
		} else {
			buildClassifierUsingResampling(data);
		}
		initializeDiversityMeasureImplementation(this, data);
	}

	/**
	 * Boosting method. Boosts using resampling
	 *
	 * @param data the training data to be used for generating the
	 * boosted classifier.
	 * @throws Exception if the classifier could not be built successfully
	 */
	protected void buildClassifierUsingResampling(Instances data) 
	throws Exception {

		Instances trainData, sample, training;
		double epsilon, reweight, sumProbs;
		Evaluation evaluation;
		int numInstances = data.numInstances();
		Random randomInstance = new Random(m_Seed);
		int resamplingIterations = 0;

		// Initialize data
		m_Betas = new double [m_Classifiers.length];
		m_NumIterationsPerformed = 0;
		// Create a copy of the data so that when the weights are diddled
		// with it doesn't mess up the weights for anyone else
		training = new Instances(data, 0, numInstances);
		sumProbs = training.sumOfWeights();
		for (int i = 0; i < training.numInstances(); i++) {
			training.instance(i).setWeight(training.instance(i).
					weight() / sumProbs);
		}

		// Do boostrap iterations
		for (m_NumIterationsPerformed = 0; m_NumIterationsPerformed < m_Classifiers.length; 
		m_NumIterationsPerformed++) {
			if (m_Debug) {
				System.err.println("Training classifier " + (m_NumIterationsPerformed + 1));
			}

			// Select instances to train the classifier on
			if (m_WeightThreshold < 100) {
				trainData = selectWeightQuantile(training, 
						(double)m_WeightThreshold / 100);
			} else {
				trainData = new Instances(training);
			}

			// Resample
			resamplingIterations = 0;
			double[] weights = new double[trainData.numInstances()];
			for (int i = 0; i < weights.length; i++) {
				weights[i] = trainData.instance(i).weight();
			}
			do {
				sample = trainData.resampleWithWeights(randomInstance, weights);

				// Build and evaluate classifier
				m_Classifiers[m_NumIterationsPerformed].buildClassifier(sample);
				evaluation = new Evaluation(data);
				evaluation.evaluateModel(m_Classifiers[m_NumIterationsPerformed], 
						training);
				epsilon = evaluation.errorRate();
				resamplingIterations++;
			} while (Utils.eq(epsilon, 0) && 
					(resamplingIterations < MAX_NUM_RESAMPLING_ITERATIONS));

			// Stop if error too big or 0
			if (Utils.grOrEq(epsilon, 0.5) || Utils.eq(epsilon, 0)) {
				if (m_NumIterationsPerformed == 0) {
					m_NumIterationsPerformed = 1; // If we're the first we have to to use it
				}
				break;
			}

			// Determine the weight to assign to this model
			m_Betas[m_NumIterationsPerformed] = Math.log((1 - epsilon) / epsilon);
			reweight = (1 - epsilon) / epsilon;
			if (m_Debug) {
				System.err.println("\terror rate = " + epsilon
						+"  beta = " + m_Betas[m_NumIterationsPerformed]);
			}

			// Update instance weights
			setWeights(training, reweight);
		}
	}

	/**
	 * Sets the weights for the next iteration.
	 * 
	 * @param training the training instances
	 * @param reweight the reweighting factor
	 * @throws Exception if something goes wrong
	 */
	protected void setWeights(Instances training, double reweight) 
	throws Exception {

		double oldSumOfWeights, newSumOfWeights;

		oldSumOfWeights = training.sumOfWeights();
		Enumeration enu = training.enumerateInstances();
		while (enu.hasMoreElements()) {
			Instance instance = (Instance) enu.nextElement();
			if (!Utils.eq(m_Classifiers[m_NumIterationsPerformed].classifyInstance(instance), 
					instance.classValue()))
				instance.setWeight(instance.weight() * reweight);
		}

		// Renormalize weights
		newSumOfWeights = training.sumOfWeights();
		enu = training.enumerateInstances();
		while (enu.hasMoreElements()) {
			Instance instance = (Instance) enu.nextElement();
			instance.setWeight(instance.weight() * oldSumOfWeights 
					/ newSumOfWeights);
		}
	}

	/**
	 * Boosting method. Boosts any classifier that can handle weighted
	 * instances.
	 *
	 * @param data the training data to be used for generating the
	 * boosted classifier.
	 * @throws Exception if the classifier could not be built successfully
	 */
	protected void buildClassifierWithWeights(Instances data) 
	throws Exception {

		Instances trainData, training;
		double epsilon, reweight;
		Evaluation evaluation;
		int numInstances = data.numInstances();
		Random randomInstance = new Random(m_Seed);

		// Initialize data
		m_Betas = new double [m_Classifiers.length];
		m_NumIterationsPerformed = 0;

		// Create a copy of the data so that when the weights are diddled
		// with it doesn't mess up the weights for anyone else
		training = new Instances(data, 0, numInstances);

		// Do boostrap iterations
		for (m_NumIterationsPerformed = 0; m_NumIterationsPerformed < m_Classifiers.length; 
		m_NumIterationsPerformed++) {
			if (m_Debug) {
				System.err.println("Training classifier " + (m_NumIterationsPerformed + 1));
			}
			// Select instances to train the classifier on
			if (m_WeightThreshold < 100) {
				trainData = selectWeightQuantile(training, 
						(double)m_WeightThreshold / 100);
			} else {
				trainData = new Instances(training, 0, numInstances);
			}

			// Build the classifier
			if (m_Classifiers[m_NumIterationsPerformed] instanceof Randomizable)
				((Randomizable) m_Classifiers[m_NumIterationsPerformed]).setSeed(randomInstance.nextInt());
			m_Classifiers[m_NumIterationsPerformed].buildClassifier(trainData);

			// Evaluate the classifier
			evaluation = new Evaluation(data);
			evaluation.evaluateModel(m_Classifiers[m_NumIterationsPerformed], training);
			epsilon = evaluation.errorRate();

			// Stop if error too small or error too big and ignore this model
			if (Utils.grOrEq(epsilon, 0.5) || Utils.eq(epsilon, 0)) {
				if (m_NumIterationsPerformed == 0) {
					m_NumIterationsPerformed = 1; // If we're the first we have to to use it
				}
				break;
			}
			// Determine the weight to assign to this model
			m_Betas[m_NumIterationsPerformed] = Math.log((1 - epsilon) / epsilon);
			reweight = (1 - epsilon) / epsilon;
			if (m_Debug) {
				System.err.println("\terror rate = " + epsilon
						+"  beta = " + m_Betas[m_NumIterationsPerformed]);
			}

			// Update instance weights
			setWeights(training, reweight);
		}
	}

	/**
	 * Calculates the class membership probabilities for the given test instance.
	 *
	 * @param instance the instance to be classified
	 * @return predicted class probability distribution
	 * @throws Exception if instance could not be classified
	 * successfully
	 */
	public double [] distributionForInstance(Instance instance) 
	throws Exception {

		// default model?
		if (m_ZeroR != null) {
			return m_ZeroR.distributionForInstance(instance);
		}

		if (m_NumIterationsPerformed == 0) {
			throw new Exception("No model built");
		}
		double [] sums = new double [instance.numClasses()]; 

		if (m_NumIterationsPerformed == 1) {
			return m_Classifiers[0].distributionForInstance(instance);
		} else {
			for (int i = 0; i < m_NumIterationsPerformed; i++) {
				sums[(int)m_Classifiers[i].classifyInstance(instance)] += m_Betas[i];
			}
			return Utils.logs2probs(sums);
		}
	}

	/**
	 * Returns the boosted model as Java source code.
	 *
	 * @param className the classname of the generated class
	 * @return the tree as Java source code
	 * @throws Exception if something goes wrong
	 */
	public String toSource(String className) throws Exception {

		if (m_NumIterationsPerformed == 0) {
			throw new Exception("No model built yet");
		}
		if (!(m_Classifiers[0] instanceof Sourcable)) {
			throw new Exception("Base learner " + m_Classifier.getClass().getName()
					+ " is not Sourcable");
		}

		StringBuffer text = new StringBuffer("class ");
		text.append(className).append(" {\n\n");

		text.append("  public static double classify(Object[] i) {\n");

		if (m_NumIterationsPerformed == 1) {
			text.append("    return " + className + "_0.classify(i);\n");
		} else {
			text.append("    double [] sums = new double [" + m_NumClasses + "];\n");
			for (int i = 0; i < m_NumIterationsPerformed; i++) {
				text.append("    sums[(int) " + className + '_' + i 
						+ ".classify(i)] += " + m_Betas[i] + ";\n");
			}
			text.append("    double maxV = sums[0];\n" +
					"    int maxI = 0;\n"+
					"    for (int j = 1; j < " + m_NumClasses + "; j++) {\n"+
					"      if (sums[j] > maxV) { maxV = sums[j]; maxI = j; }\n"+
			"    }\n    return (double) maxI;\n");
		}
		text.append("  }\n}\n");

		for (int i = 0; i < m_Classifiers.length; i++) {
			text.append(((Sourcable)m_Classifiers[i])
					.toSource(className + '_' + i));
		}
		return text.toString();
	}

	/**
	 * Returns description of the boosted classifier.
	 *
	 * @return description of the boosted classifier as a string
	 */
	public String toString() {

		// only ZeroR model?
		if (m_ZeroR != null) {
			StringBuffer buf = new StringBuffer();
			buf.append(this.getClass().getName().replaceAll(".*\\.", "") + "\n");
			buf.append(this.getClass().getName().replaceAll(".*\\.", "").replaceAll(".", "=") + "\n\n");
			buf.append("Warning: No model could be built, hence ZeroR model is used:\n\n");
			buf.append(m_ZeroR.toString());
			return buf.toString();
		}

		StringBuffer text = new StringBuffer();

		if (m_NumIterationsPerformed == 0) {
			text.append("AdaBoostM1: No model built yet.\n");
		} else if (m_NumIterationsPerformed == 1) {
			text.append("AdaBoostM1: No boosting possible, one classifier used!\n");
			text.append(m_Classifiers[0].toString() + "\n");
		} else {
			text.append("AdaBoostM1: Base classifiers and their weights: \n\n");
			for (int i = 0; i < m_NumIterationsPerformed ; i++) {
				text.append(m_Classifiers[i].toString() + "\n\n");
				text.append("Weight: " + Utils.roundDouble(m_Betas[i], 2) + "\n\n");
			}
			text.append("Number of performed Iterations: " 
					+ m_NumIterationsPerformed + "\n");
		}

		return text.toString();
	}

	/**
	 * Returns the revision string.
	 * 
	 * @return		the revision
	 */
	public String getRevision() {
		return RevisionUtils.extract("$Revision: 5928 $");
	}

	/**
	 * Main method for testing this class.
	 *
	 * @param argv the options
	 */
	public static void main(String [] argv) {
		runClassifier(new AdaBoostM1(), argv);
	}

	@Override
	public List<Classifier> getEnsembleMembers() {
		ArrayList<Classifier> baseClassifiers = new ArrayList<Classifier>(m_NumIterationsPerformed);
		for (int i = 0; i < m_NumIterationsPerformed; i++)
			baseClassifiers.add(m_Classifiers[i]);
		return baseClassifiers;
	}
}
